六边形架构：端口与适配器的实践指南

在不断发展的软件开发领域，构建健壮、可维护和可测试的应用程序至关重要。六边形架构，也称为端口与适配器，是一种架构模式，通过将应用程序的核心业务逻辑与其外部依赖解耦来解决这些问题。本指南旨在为全球开发者提供对六边形架构、其优势以及实际实现策略的全面理解。

什么是六边形架构？

六边形架构由 Alistair Cockburn 提出，其核心思想是将应用程序的核心业务逻辑与其外部世界隔离开来。这种隔离通过使用端口和适配器来实现。

• 核心（应用程序）：代表应用程序的心脏，包含业务逻辑和领域模型。它应该独立于任何特定的技术或框架。
• 端口：定义核心应用程序用于与外部世界交互的接口。它们是如何应用程序与外部系统（如数据库、用户界面或消息队列）交互的抽象定义。端口可以有两种类型：
  • 驱动（主）端口：定义外部参与者（例如，用户、其他应用程序）可以在其中启动核心应用程序内操作的接口。
  • 被驱动（次）端口：定义核心应用程序用于与外部系统（例如，数据库、消息队列）交互的接口。
• 适配器：实现端口定义的接口。它们充当核心应用程序与外部系统之间的翻译器。有两种类型的适配器：
  • 驱动（主）适配器：实现驱动端口，将外部请求转换为核心应用程序可以理解的命令或查询。示例包括用户界面组件（例如，Web 控制器）、命令行界面或消息队列侦听器。
  • 被驱动（次）适配器：实现被驱动端口，将核心应用程序的请求转换为与外部系统的特定交互。示例包括数据库访问对象、消息队列生产者或 API 客户端。

可以这样理解：核心应用程序位于中心，被六边形外壳包围。端口是该外壳的入口和出口，适配器插入这些端口，将核心连接到外部世界。

六边形架构的关键原则

几个关键原则支撑着六边形架构的有效性：

• 依赖倒置：核心应用程序依赖于抽象（端口），而不是具体的实现（适配器）。这是 SOLID 设计的核心原则。
• 显式接口：端口清晰地定义了核心与外部世界之间的边界，促进了基于契约的集成方法。
• 可测试性：通过将核心与外部依赖解耦，可以更轻松地使用端口的模拟实现来隔离测试业务逻辑。
• 灵活性：可以在不影响核心应用程序的情况下轻松地替换适配器，从而轻松适应不断变化的技术或需求。想象一下需要从 MySQL 切换到 PostgreSQL；只需更改数据库适配器即可。

使用六边形架构的好处

采用六边形架构提供了许多优势：

• 改进的可测试性：关注点的分离使得编写核心业务逻辑的单元测试变得更加容易。模拟端口允许您隔离核心并对其进行彻底测试，而无需依赖外部系统。例如，可以通过模拟支付网关端口来测试支付处理模块，模拟成功和失败的交易，而无需实际连接到真实网关。
• 增强的可维护性：外部系统或技术的变化对核心应用程序的影响最小。适配器充当绝缘层，保护核心免受外部波动。考虑这样一个场景：用于发送 SMS 通知 của 第三方 API 更改了其格式或身份验证方法。只需更新 SMS 适配器，核心应用程序保持不变。
• 增强的灵活性：适配器可以轻松切换，从而可以适应新技术或需求，而无需进行重大重构。这有利于实验和创新。一家公司可能会决定将其数据存储从传统的​​关系数据库迁移到 NoSQL 数据库。借助六边形架构，只需替换数据库适配器即可，从而最大程度地减少对核心应用程序的干扰。
• 降低耦合度：核心应用程序与外部依赖解耦，实现了更模块化和更一致的设计。这使得代码库更易于理解、修改和扩展。
• 独立开发：不同的团队可以独立地开发核心应用程序和适配器，从而促进并行开发和更快的上市时间。例如，一个团队可以专注于开发核心订单处理逻辑，而另一个团队可以构建用户界面和数据库适配器。

实施六边形架构：实践示例

让我们通过一个简化的用户注册系统示例来说明六边形架构的实现。我们将使用一种假设的编程语言（类似于 Java 或 C#）来说明。

1. 定义核心（应用程序）

核心应用程序包含注册新用户的业务逻辑。

// Core/UserService.java (或 UserService.cs)
public class UserService {
    private final UserRepository userRepository;
    private final PasswordHasher passwordHasher;
    private final UserValidator userValidator;

    public UserService(UserRepository userRepository, PasswordHasher passwordHasher, UserValidator userValidator) {
        this.userRepository = userRepository;
        this.passwordHasher = passwordHasher;
        this.userValidator = userValidator;
    }

    public Result<User, String> registerUser(String username, String password, String email) {
        // Validate user input
        ValidationResult validationResult = userValidator.validate(username, password, email);
        if (!validationResult.isValid()) {
            return Result.failure(validationResult.getErrorMessage());
        }

        // Check if user already exists
        if (userRepository.findByUsername(username).isPresent()) {
            return Result.failure("Username already exists");
        }

        // Hash the password
        String hashedPassword = passwordHasher.hash(password);

        // Create a new user
        User user = new User(username, hashedPassword, email);

        // Save the user to the repository
        userRepository.save(user);

        return Result.success(user);
    }
}

2. 定义端口

我们定义核心应用程序用于与外部世界交互的端口。

// Ports/UserRepository.java (或 UserRepository.cs)
public interface UserRepository {
    Optional<User> findByUsername(String username);
    void save(User user);
}

// Ports/PasswordHasher.java (或 PasswordHasher.cs)
public interface PasswordHasher {
    String hash(String password);
}

//Ports/UserValidator.java (或 UserValidator.cs)
public interface UserValidator{
  ValidationResult validate(String username, String password, String email);
}

//Ports/ValidationResult.java (或 ValidationResult.cs)
public interface ValidationResult{
  boolean isValid();
  String getErrorMessage();
}

3. 定义适配器

我们实现将核心应用程序连接到特定技术的适配器。

// Adapters/DatabaseUserRepository.java (或 DatabaseUserRepository.cs)
public class DatabaseUserRepository implements UserRepository {
    private final DatabaseConnection databaseConnection;

    public DatabaseUserRepository(DatabaseConnection databaseConnection) {
        this.databaseConnection = databaseConnection;
    }

    @Override
    public Optional<User> findByUsername(String username) {
        // Implementation using JDBC, JPA, or another database access technology
        // ...
        return Optional.empty(); // Placeholder
    }

    @Override
    public void save(User user) {
        // Implementation using JDBC, JPA, or another database access technology
        // ...
    }
}

// Adapters/BCryptPasswordHasher.java (或 BCryptPasswordHasher.cs)
public class BCryptPasswordHasher implements PasswordHasher {
    @Override
    public String hash(String password) {
        // Implementation using BCrypt library
        // ...
        return "hashedPassword"; //Placeholder
    }
}

//Adapters/SimpleUserValidator.java (或 SimpleUserValidator.cs)
public class SimpleUserValidator implements UserValidator {
  @Override
  public ValidationResult validate(String username, String password, String email){
    //Simple Validation logic
     if (username == null || username.isEmpty()) {
            return new SimpleValidationResult(false, "Username cannot be empty");
        }
        if (password == null || password.length() < 8) {
            return new SimpleValidationResult(false, "Password must be at least 8 characters long");
        }
        if (email == null || !email.contains("@")) {
            return new SimpleValidationResult(false, "Invalid email format");
        }

        return new SimpleValidationResult(true, null);
  }
}

//Adapters/SimpleValidationResult.java (或 SimpleValidationResult.cs)
public class SimpleValidationResult implements ValidationResult {
  private final boolean valid;
  private final String errorMessage;

    public SimpleValidationResult(boolean valid, String errorMessage) {
        this.valid = valid;
        this.errorMessage = errorMessage;
    }
  @Override
  public boolean isValid(){
    return valid;
  }

  @Override
  public String getErrorMessage(){
    return errorMessage;
  }
}



//Adapters/WebUserController.java (或 WebUserController.cs)
//Driving Adapter - handles requests from the web
public class WebUserController {
    private final UserService userService;

    public WebUserController(UserService userService) {
        this.userService = userService;
    }

    public String registerUser(String username, String password, String email) {
        Result<User, String> result = userService.registerUser(username, password, email);
        if (result.isSuccess()) {
            return "Registration successful!";
        } else {
            return "Registration failed: " + result.getFailure();
        }
    }
}

4. 组合

将所有内容连接起来。请注意，此组合（依赖注入）通常发生在应用程序的入口点或依赖注入容器中。

//Main class or dependency injection configuration
public class Main {
    public static void main(String[] args) {
        // Create instances of the adapters
        DatabaseConnection databaseConnection = new DatabaseConnection("jdbc:mydb://localhost:5432/users", "user", "password");
        DatabaseUserRepository userRepository = new DatabaseUserRepository(databaseConnection);
        BCryptPasswordHasher passwordHasher = new BCryptPasswordHasher();
        SimpleUserValidator userValidator = new SimpleUserValidator();

        // Create an instance of the core application, injecting the adapters
        UserService userService = new UserService(userRepository, passwordHasher, userValidator);

        //Create a driving adapter and connect it to the service
        WebUserController userController = new WebUserController(userService);

        //Now you can handle user registration requests through the userController
        String result = userController.registerUser("john.doe", "P@sswOrd123", "john.doe@example.com");
        System.out.println(result);
    }
}



//DatabaseConnection is a simple class for demonstration purposes only
class DatabaseConnection {
    private String url;
    private String username;
    private String password;

    public DatabaseConnection(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }

    // ... methods to connect to the database (not implemented for brevity)
}

//Result class (similar to Either in functional programming)
class Result<T, E> {
    private final T success;
    private final E failure;
    private final boolean isSuccess;

    private Result(T success, E failure, boolean isSuccess) {
        this.success = success;
        this.failure = failure;
        this.isSuccess = isSuccess;
    }

    public static <T, E> Result<T, E> success(T value) {
        return new Result<>(value, null, true);
    }

    public static <T, E> Result<T, E> failure(E error) {
        return new Result<>(null, error, false);
    }

    public boolean isSuccess() {
        return isSuccess;
    }

    public T getSuccess() {
        if (!isSuccess) {
            throw new IllegalStateException("Result is a failure");
        }
        return success;
    }

    public E getFailure() {
        if (isSuccess) {
            throw new IllegalStateException("Result is a success");
        }
        return failure;
    }
}

class User {
    private String username;
    private String password;
    private String email;

    public User(String username, String password, String email) {
        this.username = username;
        this.password = password;
        this.email = email;
    }

    // getters and setters (omitted for brevity)

}

Explanation:

• UserService 代表核心业务逻辑。它依赖于 UserRepository、PasswordHasher 和 UserValidator 接口（端口）。
• DatabaseUserRepository、BCryptPasswordHasher 和 SimpleUserValidator 是实现相应端口的适配器，它们使用具体的（数据库、BCrypt 和基本验证逻辑）技术。
• WebUserController 是一个驱动适配器，它处理 Web 请求并与 UserService 进行交互。
• main 方法组合了应用程序，创建了适配器的实例并将其注入核心应用程序。

高级注意事项和最佳实践

虽然六边形架构的基本原理很简单，但有一些高级注意事项需要牢记：

• 选择合适的端口粒度：确定端口的合适抽象级别至关重要。过于细粒度的端口可能导致不必要的复杂性，而过于粗粒度的端口可能会限制灵活性。在定义端口时，请考虑简洁性和适应性之间的权衡。
• 事务管理：在处理多个外部系统时，确保事务一致性可能具有挑战性。考虑使用分布式事务管理技术或实现补偿事务来维护数据完整性。例如，如果注册用户涉及在单独的计费系统中创建账户，则需要确保这两个操作一起成功或失败。
• 错误处理：实施强大的错误处理机制，以优雅地处理外部系统中的故障。使用断路器或重试机制来防止级联故障。当适配器无法连接到数据库时，应用程序应优雅地处理错误，并可能重试连接或向用户提供信息性错误消息。
• 测试策略：采用单元测试、集成测试和端到端测试的组合来确保应用程序的质量。单元测试应侧重于核心业务逻辑，而集成测试应验证核心与适配器之间的交互。
• 依赖注入框架：利用依赖注入框架（例如 Spring、Guice）来管理组件之间的依赖关系并简化应用程序的组合。这些框架会自动处理依赖项的创建和注入，从而减少样板代码并提高可维护性。
• CQRS（命令查询责任分离）：六边形架构与 CQRS 非常契合，您可以在其中分离应用程序的读写模型。这可以进一步提高复杂系统中的性能和可扩展性。

实际应用中的六边形架构示例

许多成功的公司和项目都采用了六边形架构来构建健壮且可维护的系统：

• 电子商务平台：电子商务平台通常使用六边形架构将核心订单处理逻辑与各种外部系统（如支付网关、运输提供商和库存管理系统）解耦。这使他们能够在不中断核心功能的情况下轻松集成新的支付方式或运输选项。
• 金融应用：金融应用程序，如银行系统和交易平台，受益于六边形架构提供的可测试性和可维护性。核心金融逻辑可以在隔离环境中得到彻底测试，并且可以使用适配器连接到各种外部服务，如市场数据提供商和清算所。
• 微服务架构：六边形架构非常适合微服务架构，其中每个微服务代表一个具有自身核心业务逻辑和外部依赖项的有界上下文。端口和适配器为微服务之间的通信提供了清晰的合同，促进了松耦合和独立部署。
• 遗留系统现代化：六边形架构可以通过将现有代码封装在适配器中并在端口后面引入新的核心逻辑来逐步现代化遗留系统。这使得您可以在不重写整个应用程序的情况下逐步替换遗留系统的部分。

挑战和权衡

虽然六边形架构提供了显著的好处，但重要的是要认识到所涉及的挑战和权衡：

• 复杂性增加：实施六边形架构可能会引入额外的抽象层，这可能会增加代码库的初始复杂性。
• 学习曲线：开发人员可能需要一些时间来理解端口和适配器的概念以及如何有效地应用它们。
• 过度设计的可能性：重要的是要避免创建不必要的端口和适配器而过度设计。从简单的设计开始，并根据需要逐步添加复杂性。
• 性能考虑：额外的抽象层可能会带来一些性能开销，尽管在大多数应用程序中这通常是微不足道的。

仔细评估六边形架构在您的特定项目需求和团队能力下的好处和挑战至关重要。它不是万能的，它可能并非适用于所有项目。

结论

六边形架构通过其对端口和适配器的强调，提供了一种构建可维护、可测试和灵活应用程序的强大方法。通过将核心业务逻辑与外部依赖解耦，它可以让您轻松适应不断变化的技术和需求。虽然存在挑战和权衡需要考虑，但六边形架构的优势通常会超过成本，特别是对于复杂且长期的应用程序。通过拥抱依赖倒置和显式接口的原则，您可以创建更具弹性、更易于理解并且能更好地满足现代软件格局需求的系统。

本指南提供了六边形架构的全面概述，从其核心原则到实际实现策略。我们鼓励您进一步探索这些概念，并在您自己的项目中尝试应用它们。学习和采用六边形架构的投资无疑将在长期内获得回报，带来更高质量的软件和更满意的开发团队。

最终，选择正确的架构取决于您项目的具体需求。在做出决定时，请考虑复杂性、使用寿命和可维护性要求。六边形架构为构建健壮且适应性强的应用程序提供了坚实的基础，但它只是软件架构师工具箱中的一个工具。